/*
 * @Author: your name
 * @Date: 2021-12-07 16:10:23
 * @LastEditTime: 2021-12-08 16:38:44
 * @LastEditors: Please set LastEditors
 * @Description: 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
 * @FilePath: /vite_vue3_ts/src/utils/http/axios/index.ts
 */
import { HAxios } from './Axios';
import { AxiosTransform } from './axiosTransform';
import axios, { AxiosResponse } from 'axios';
import { RequestEnum, ResultEnum, ContentTypeEnum } from '@/enums/httpEnum';
import { PageEnum } from '@/enums/pageEnum';
import { checkStatus } from './checkStatus';
import { RequestOptions, Result } from './types';
import router from '@/router';
import { storage } from '@/utils/Storage';
import { isString } from '@/utils/is/';
import { joinTimestamp, formatRequestDate } from './helper';

import { setObjToUrlParams } from '@/utils/urlUtils';

import { useUserStoreWidthOut } from '@/store/modules/user';

/*
 *@Description: 处理数据，方便区分多种处理方式
 *@Author: huoran
 *@Date: 2021-12-08 10:52:11
 */
const transform: AxiosTransform = {
  // 处理响应数据
  transformRequestData: (res: AxiosResponse<Result>, options: RequestOptions) => {
    const { $message: Message, $dialog: Modal } = window;
    const {
      isShowMessage = true,
      isShowErrorMessage,
      isShowSuccessMessage,
      successMessageText,
      errorMessageText,
      isTransformResponse,
      isReturnNativeResponse
    } = options;

    // 是否返回原生响应头 比如：需要获取响应头时使用该属性
    if (isReturnNativeResponse) {
      return res;
    }

    // 不进行任何处理，直接返回
    // 用于页面代码可能需要直接获取code，data，message这些信息时开启
    if (!isTransformResponse) {
      return res.data;
    }

    const reject = Promise.reject;

    const { data } = res;

    if (!data) {
      // 没有返回值 return '[HTTP] Request has no return value';
      return reject(data);
    }

    // 这里code， result， message为 后台统一的字段，需要在types.ts内修改为项目自己的接口返回格式
    const { code, result, message } = data;
    // 请求成功    Reflect.has(target, propertyKey) target-目标对象  propertyKey-属性名，需要检查目标对象是否存在此属性  返回boolean
    const hasSuccess = data && Reflect.has(data, 'code') && code === ResultEnum.SUCCESS;
    // 是否显示提示信息

    if (isShowMessage) {
      if (hasSuccess && (successMessageText || isShowSuccessMessage)) {
        // 是否显示自定义信息提示
        Message.success(successMessageText || message || '操作成功！');
      } else if (!hasSuccess && (errorMessageText || isShowErrorMessage)) {
        // 失败处理

        Message.error(message || errorMessageText || '操作失败！');
      } else if (!hasSuccess && options.errorMessageMode === 'modal') {
        // errorMessageMode=‘custom-modal’的时候会显示modal错误弹窗，而不是消息提示，用于一些比较重要的错误
        Modal.info({
          title: '提示',
          content: message,
          positiveText: '确定',
          onPositiveClick: () => {}
        });
      }
    }

    // 接口请求成功, 直接返回结果
    if (code === ResultEnum.SUCCESS) {
      return result;
    }

    // 接口请求错误，统一提示错误信息
    if (code === ResultEnum.ERROR) {
      if (message) {
        Message.error(data.message);
        Promise.reject(new Error(message));
      } else {
        const msg = '操作失败,系统异常!';
        Message.error(msg);
        Promise.reject(new Error(msg));
      }
      return reject();
    }

    // 登录超时
    if (code === ResultEnum.TIMEOUT) {
      const LoginName = PageEnum.BASE_LOGIN_NAME;
      // 如果在登录页，不动
      if (router.currentRoute.value.name == LoginName) return;
      // 到登录页
      const timeoutMsg = '登录超时,请重新登录!';
      Modal.warning({
        title: '提示',
        content: '登录身份已失效，请重新登录!',
        positiveText: '确定',
        negativeText: '取消',
        onPositiveClick: () => {
          storage.clear();
          router.replace({
            name: LoginName,
            query: {
              redirect: router.currentRoute.value.fullPath
            }
          });
        },
        onNegativeClick: () => {}
      });
      return reject(new Error(timeoutMsg));
    }

    // 这里逻辑可以根据项目进行修改
    if (!hasSuccess) {
      return reject(new Error(message));
    }
    return data;
  },

  // 请求之前处理config
  beforeRequestHook: (config, options) => {
    const { apiUrl, joinPrefix, joinParamsToUrl, formatDate, joinTime = true } = options;

    // 是否加入url
    // if (joinPrefix) {
    //     config.url = `${urlPre}`
    // }

    if (apiUrl && isString(apiUrl)) {
      config.url = `${apiUrl}${config.url}`;
    }

    const params = config.params || {};
    const data = config.data || false;
    // get请求
    if (config.method?.toUpperCase() === RequestEnum.GET) {
      if (!isString(params)) {
        // 给 get 请求加上时间戳参数，避免从缓存中拿数据
        config.params = Object.assign(params || {}, joinTimestamp(joinTime, false));
      } else {
        // 兼容restful风格
        config.url = config.url + params + `${joinTimestamp(joinTime, true)}`;
        config.params = undefined;
      }
    } else {
      if (!isString(params)) {
        formatDate && formatRequestDate(params);
        if (Reflect.has(config, 'data') && config.data && Object.keys(config.data).length) {
          config.data = data;
          config.params = params;
        } else {
          config.data = params;
          config.params = undefined;
        }

        // 请求参数拼接到url
        if (joinParamsToUrl) {
          config.url = setObjToUrlParams(config.url as string, Object.assign({}, config.params, config.data));
        }
      } else {
        // 兼容restful风格
        config.url = config.url + params;
        config.params = undefined;
      }
    }
    // console.log("beforeRequestHook: ", config);
    return config;
  },

  /*
   *@Description: 请求拦截器处理
   *@Author: huoran
   *@Date: 2021-12-08 14:09:57
   */
  requestInterceptors: config => {
    // 请求之前处理config
    const userStore = useUserStoreWidthOut();
    const token = userStore.getToken;
    if (token) {
      config.headers.token = token;
    }
    return config;
  },

  /*
   *@Description: 响应处理
   *@Author: huoran
   *@Date: 2021-12-08 14:18:47
   */
  responseInterceptorsCatch: (error: any) => {
    const { $message: Message, $dialog: Modal } = window;
    const { response, code, message } = error || {};
    // TODO 此处要根据后端接口返回格式修改
    const msg: string = response && response.data && response.data.message ? response.data.message : '';
    const err: string = error.toString();
    try {
      if (code === 'ECONNABORTED' && message.indexOf('timeout') !== -1) {
        Message.error('接口请求超时，请刷新页面重试！');
        return;
      }
      if (err && err.includes('Network Error')) {
        Modal.info({
          title: '网络异常',
          content: '请检查您的网络连接是否正常!',
          positiveText: '确定',
          onPositiveClick: () => {}
        });
        return;
      }
    } catch (error) {
      throw new Error(error);
    }
    // 请求是否被取消
    const isCancel = axios.isCancel(error);
    if (!isCancel) {
      checkStatus(error.response && error.response.status, msg, Message);
    } else {
      console.warn(error, '请求被取消！');
    }
    return error;
  }
};

const Axios = new HAxios({
  timeout: 10 * 1000,
  // 接口前缀
  prefixUrl: '/api',
  headers: { 'Content-Type': ContentTypeEnum.JSON },
  // 数据处理方式
  transform,
  // 配置项，下面的选项都可以在独立的接口请求中覆盖
  requestOptions: {
    // 默认将prefix 添加到url
    joinPrefix: true,
    // 是否返回原生响应头 比如：需要获取响应头时使用该属性
    isReturnNativeResponse: false,
    // 需要对返回数据进行处理
    isTransformResponse: true,
    // post请求的时候添加参数到url
    joinParamsToUrl: false,
    // 格式化提交参数时间
    formatDate: true,
    // 消息提示类型
    errorMessageMode: 'none',
    // 接口地址
    apiUrl: 'http://192.168.1.88:9080/api'
  },
  withCredentials: false
});

export default Axios;
